#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;

// 全局的命令行参数表
char* gargv[argvnum];
int gargc = 0;

// 全局的变量
int lastcode = 0;

// 我系统的环境变量
char* genv[envnum];

// 全局的当前shell工作路径
char pwd[basesize];
char pwdenv[basesize];

// 获取用户名
string GetUserName()
{
    string name = getenv("USER");
    return name.empty() ? "None" : name;
}

// 获取主机名
string GetHostName()
{
    string hostname = getenv("HOSTNAME");
    
    return hostname.empty() ? "None" : hostname;
}

// 获取路径
string GetPwd()
{
    //string pwd = getenv("PWD");       // 不使用环境变量直接获取路径
    //return pwd.empty() ? "None" : pwd;

    // 使用系统调用getcwp获取路径
    if(nullptr == getcwd(pwd, sizeof(pwd)))   return "None"; 
    snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);
    putenv(pwdenv);
    return pwd;
    
}

// 截取路径的最后一个/XXX
string LastDir()
{
    string curr = GetPwd();
    if(curr == "/" || curr == "None")   return curr;
    
    size_t pos = curr.rfind("/");
    if(pos == std::string::npos)    return curr;
    
    return curr.substr(pos + 1);
}

// 输入命令行
string MakeCommandLine()
{
    char command_line[basesize];
    snprintf(command_line, basesize, "[%s@%s %s]# ",\
            GetUserName().c_str(), GetHostName().c_str(), LastDir().c_str());

    return command_line;
}

// 1.打印命令行提示符
void PrintCommandLine() 
{
    printf("%s", MakeCommandLine().c_str());
    fflush(stdout);
}


// 2.获取用户命令
bool  GetCommandLine(char command_buffer[], int size)
{
    // 我们认为，我们要将用户输入的命令行，当作一个完整的字符串
    // "ls -a -l -n"
    char* result = fgets(command_buffer, size, stdin);
    if(!result)
    {
        return false;
    }

    command_buffer[strlen(command_buffer) - 1] = 0; // 将从键盘上获取的回车删除

    if(strlen(command_buffer) == 0)  return false;  // 数组command_buffer为空时，return
    return true;
}




// 3.分析命令
void ParseCommandLine(char command_buffer[], int len)
{
    (void) len;
    // 每一次执行该程序，都进行一次清空
    memset(gargv, 0, sizeof(gargv));
    gargc = 0;
    
    // "ls -a -l -n"
    const char *sep = " ";
    gargv[gargc++] = strtok(command_buffer, sep);

    while( (bool)(gargv[gargc++] = strtok(nullptr, sep)) );
    gargc--;
}

void debug()
{
    printf("argc: %d\n", gargc);
    for(int i = 0; gargv[i];i++)
    {
        printf("atgv[%d]: %s\n", i, gargv[i]);
    }
}

// 4.执行命令
bool ExecuteCommand()
{
    // 让子进程执行代码
    pid_t id = fork();
    if(id < 0) return false;
    if(id == 0)
    {
        // 子进程 
        // 1. 执行命令
        //execvp(gargv[0], gargv);
        
        execvpe(gargv[0], gargv, genv);
        // 2.退出
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        // Do nothing
        if(WIFEXITED(status))
        {
            lastcode = WEXITSTATUS(status);
        }
        else
        {
            lastcode = 100;
        }
        
        return true;
    }
    return false;
}

void AddEnv(const char* item)
{
    int index = 0;
    while(genv[index])
    {
        index++;
    }
    genv[index] = (char*)malloc(strlen(item) + 1);
    strncpy(genv[index], item, strlen(item) + 1);
    genv[++index] = nullptr;
}

// shell自己执行命令，本质是shell调用自己的函数
bool CheckAndExecBuiltCommand() 
{
    if(strcmp(gargv[0], "cd") == 0)
    {
        // 内建命令
        if(gargc == 2)
        {
            chdir(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if(strcmp(gargv[0], "export") == 0)
    {
        // export也是内建命令
        if(gargc == 2)
        {
            AddEnv(gargv[1]);
            lastcode = 0;
        } 
        else
        {
            lastcode = 2;
        }
        return true;
    }
    else if(strcmp(gargv[0], "env") == 0)
    {
        for(int i = 0; genv[i]; i++)
        {
            printf("%s\n", genv[i]);
        }
        lastcode = 0;
        return true;
    }
    else if(strcmp(gargv[0], "echo") == 0)
    {
        if(gargc == 2)
        {
            // echo $?
            // echo hello
            if(gargv[1][0] == '$')
            {
                if(gargv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    lastcode = 0;
                }
            }
            else
            {
                printf("%s\n", gargv[1]);
                lastcode = 0;
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }
    return false;
}

// 作为一个shell，获取环境变量应该从系统的配置文件中来
// 我们今天就直接从父进程shell中直接获取环境变量
// 在自己的shell中导入系统的环境变量
// 即，将系统的环境变量拷贝了一份给自己的shell
void InitEnv()
{
    extern char **environ;
    int index = 0;
    while(environ[index])
    {
        genv[index] = (char*)malloc(strlen(environ[index] + 1));
        strncpy(genv[index], environ[index], strlen(environ[index]) + 1);
        index++;
    }
    genv[index] = nullptr;
}


// 主函数
int main()
{
    // 初始化环境变量表
    InitEnv();

    char command_buffer[basesize];  //为了获取用户输入

    while(true)
    {
        PrintCommandLine(); // 1.命令行提示符
        //printf("\n");
        //sleep(100);
        
        // command_buffer ->输出型参数
        if( !GetCommandLine(command_buffer, basesize) )   // 2.获取用户命令
        {
            continue;
        }
        //printf("%s\n", command_buffer);
        
        ParseCommandLine(command_buffer, strlen(command_buffer)); // 3.分析命令
        
        // 测试 ParseCommandLine
        //debug();
        
        // 判断是否为内建命令
        if( CheckAndExecBuiltCommand() )
        {
            continue;
        }

        ExecuteCommand();   // 4.执行命令
    }

    return 0;
}

